module klang.klang.转换工厂.实例化代码.内置函数.内置函数_;
import 全局;
import ··Klang节点_ = klang.klang.语法节点.Klang节点_;
import ··klang类型_ = klang.klang.类型.klang类型_;
import ··节点_ = klang.编译.语法节点.节点_;
import klang.编译.核心.核心_: 词典_, 创建数组, 映射, 整数_;
import klang.klang.节点工厂.Klang工厂_: 节点工厂_ = Klang节点工厂_;
import klang.klang.转换工厂.实例化代码.类型.实例化使用类型_: 未整合的源文件_, 实例化引用标志_, 实例化引用_, 类型打印标志_, 类型打印环境_;
import klang.klang.检查.klang检查_: Klang转换支持_;
import klang.klang.类型.klang类型_: 类型_ = Klang类型_, 符号_ = Klang符号_, 签名_ = Klang签名_, KSK, 复合标志_, 符号标志_, 内置类型_, 限定符_, 内部符号名_;
import klang.klang.转换工厂.实例化代码.工具.工具_: 实例化类型, 获取合成节点扩展;
import klang.klang.语法节点.Klang节点_: 修饰符_, 标识符修饰符_, 外部修饰符声明_, Klang令牌_, 形参声明_, 类型引用_, 限定名_, 标识符_, 函数声明_, 函数类型节点_ = 函数类型_;
节点工厂_ fc;
Klang转换支持_ K;
类型_ voidTy;
类型_ boolTy;
类型_ ubyteTy;
类型_ intTy;
类型_ uintTy;
类型_ ulongTy;
类型_ sizeTy;
类型_ dcharTy;
类型_ voidPtrTy;
类型_ voidArrayTy;
类型_ voidArrayPtrTy;
类型_ stringTy;
类型_ wstringTy;
类型_ dstringTy;
类型_ aaTy;
类型_ objectTy;
类型_ throwableTy;
类型_ typeInfoTy;
类型_ enumTypeInfoTy;
类型_ pointerTypeInfoTy;
类型_ arrayTypeInfoTy;
类型_ staticArrayTypeInfoTy;
类型_ aaTypeInfoTy;
类型_ vectorTypeInfoTy;
类型_ functionTypeInfoTy;
类型_ delegateTypeInfoTy;
类型_ classInfoTy;
类型_ interfaceTypeInfoTy;
类型_ structTypeInfoTy;
类型_ tupleTypeInfoTy;
类型_ constTypeInfoTy;
类型_ invariantTypeInfoTy;
类型_ sharedTypeInfoTy;
类型_ inoutTypeInfoTy;
类型_ cppTypeInfoPtrTy;
类型_ moduleInfoTy;
标识符修饰符_[][] NoAttrs;
标识符修饰符_[][] Attr_NoAlias;
标识符修饰符_[][] Attr_NoUnwind;
标识符修饰符_[][] Attr_ReadOnly;
标识符修饰符_[][] Attr_Cold;
标识符修饰符_[][] Attr_Cold_NoReturn;
标识符修饰符_[][] Attr_Cold_NoReturn_NoUnwind;
标识符修饰符_[][] Attr_ReadOnly_NoUnwind;
标识符修饰符_[][] Attr_ReadOnly_1_NoCapture;
标识符修饰符_[][] Attr_ReadOnly_1_3_NoCapture;
标识符修饰符_[][] Attr_ReadOnly_NoUnwind_1_NoCapture;
标识符修饰符_[][] Attr_ReadOnly_NoUnwind_1_2_NoCapture;
标识符修饰符_[][] Attr_1_NoCapture;
标识符修饰符_[][] Attr_1_2_NoCapture;
标识符修饰符_[][] Attr_1_3_NoCapture;
标识符修饰符_[][] Attr_1_4_NoCapture;
类型打印环境_ 当前打印环境;
enum 形参修饰符_ : int {
    无_ = 0,
    引用_ = 1,
    输入_ = 2,
    输出_ = 4,
    常量_ = 8
}
struct 名称及类型_ {
    dstring 名称;
    类型_ 类型;
    形参修饰符_ 修饰符 = 形参修饰符_.无_;
}
void 初始环境(节点工厂_ _fc, Klang转换支持_ _K) {
    .fc = _fc;
    .K = _K;
    .voidTy = K.获取内置类型(内置类型_.无值类型);
    .boolTy = K.获取内置类型(内置类型_.真假类型);
    .ubyteTy = K.获取内置类型(内置类型_.正整数8类型);
    .intTy = K.获取内置类型(内置类型_.整数32类型);
    .uintTy = K.获取内置类型(内置类型_.正整数32类型);
    .ulongTy = K.获取内置类型(内置类型_.正整数64类型);
    .sizeTy = K.获取内置类型(内置类型_.无符号正量类型);
    .dcharTy = K.获取内置类型(内置类型_.字符32类型);
    .voidPtrTy = K.获取内置类型(内置类型_.无值指针类型);
    .voidArrayTy = K.获取内置类型(内置类型_.无值动态数组类型);
    .voidArrayPtrTy = K.创建指针类型(.voidArrayTy);
    .stringTy = K.获取内置类型(内置类型_.文本8类型);
    .wstringTy = K.获取内置类型(内置类型_.文本16类型);
    .dstringTy = K.获取内置类型(内置类型_.文本32类型);
    .objectTy = K.获取内置类型(内置类型_.全局对象类型);
    .throwableTy = K.获取内置类型(内置类型_.全局错误类型);
    .aaTy = .voidPtrTy;
    .typeInfoTy = K.创建虚拟类型("TypeInfo"d);
    .enumTypeInfoTy = K.创建虚拟类型("TypeInfo_Enum"d);
    .pointerTypeInfoTy = K.创建虚拟类型("TypeInfo_Pointer"d);
    .arrayTypeInfoTy = K.创建虚拟类型("TypeInfo_Array"d);
    .staticArrayTypeInfoTy = K.创建虚拟类型("TypeInfo_StaticArray"d);
    .aaTypeInfoTy = K.创建虚拟类型("TypeInfo_AssociativeArray"d);
    .vectorTypeInfoTy = K.创建虚拟类型("TypeInfo_Vector"d);
    .functionTypeInfoTy = K.创建虚拟类型("TypeInfo_Function"d);
    .delegateTypeInfoTy = K.创建虚拟类型("TypeInfo_Delegate"d);
    .classInfoTy = K.创建虚拟类型("TypeInfo_Class"d);
    .interfaceTypeInfoTy = K.创建虚拟类型("TypeInfo_Interface"d);
    .structTypeInfoTy = K.创建虚拟类型("TypeInfo_Struct"d);
    .tupleTypeInfoTy = K.创建虚拟类型("TypeInfo_Tuple"d);
    .constTypeInfoTy = K.创建虚拟类型("TypeInfo_Const"d);
    .invariantTypeInfoTy = K.创建虚拟类型("TypeInfo_Invariant"d);
    .sharedTypeInfoTy = K.创建虚拟类型("TypeInfo_Shared"d);
    .inoutTypeInfoTy = K.创建虚拟类型("TypeInfo_Inout"d);
    .cppTypeInfoPtrTy = K.创建虚拟类型("__cpp_type_info_ptr"d);
    .moduleInfoTy = K.创建虚拟类型("ModuleInfo"d);
    .NoAttrs = 创建数组!(标识符修饰符_[])();
    .Attr_NoAlias = .创建特性组(.NoAttrs, 1, [.获取特性标识符外部("NoAlias"d)]);
    .Attr_NoUnwind = .创建特性组(.NoAttrs, 0, [.获取特性标识符外部("NoUnwind"d)]);
    .Attr_ReadOnly = .创建特性组(.NoAttrs, 0, [.获取特性标识符外部("ReadOnly"d)]);
    .Attr_Cold = .创建特性组(.Attr_Cold, 0, [.获取特性标识符外部("Cold"d)]);
    .Attr_Cold_NoReturn = .创建特性组(.Attr_Cold, 0, [.获取特性标识符外部("NoReturn"d)]);
    .Attr_Cold_NoReturn_NoUnwind = .创建特性组(.Attr_Cold, 0, [.获取特性标识符外部("NoUnwind"d)]);
    .Attr_ReadOnly_NoUnwind = .创建特性组(.Attr_ReadOnly, 0, [.获取特性标识符外部("NoUnwind"d)]);
    .Attr_ReadOnly_1_NoCapture = .创建特性组(.Attr_ReadOnly, 2, [.获取特性标识符外部("NoCapture"d)]);
    .Attr_ReadOnly_1_3_NoCapture = .创建特性组(.Attr_ReadOnly_1_NoCapture, 4, [.获取特性标识符外部("NoCapture"d)]);
    .Attr_ReadOnly_NoUnwind_1_NoCapture = .创建特性组(.Attr_ReadOnly_1_NoCapture, 0, [.获取特性标识符外部("NoUnwind"d)]);
    .Attr_ReadOnly_NoUnwind_1_2_NoCapture = .创建特性组(.Attr_ReadOnly_NoUnwind_1_NoCapture, 3, [.获取特性标识符外部("NoCapture"d)]);
    .Attr_1_NoCapture = .创建特性组(.NoAttrs, 2, [.获取特性标识符外部("NoCapture"d)]);
    .Attr_1_2_NoCapture = .创建特性组(.Attr_1_NoCapture, 3, [.获取特性标识符外部("NoCapture"d)]);
    .Attr_1_3_NoCapture = .创建特性组(.Attr_1_NoCapture, 4, [.获取特性标识符外部("NoCapture"d)]);
    .Attr_1_4_NoCapture = .创建特性组(.Attr_1_NoCapture, 5, [.获取特性标识符外部("NoCapture"d)]);
}
函数声明_ 创建内置函数声明(dstring 名称, 类型打印环境_ 打印环境) {
    .当前打印环境 = 打印环境;
    switch (名称) {
        case "__cyg_profile_func_exit"d: {
            名称及类型_ ···tempS·0·_1;
            {
                ···tempS·0·_1.名称 = "callee"d;
                ···tempS·0·_1.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_2;
            {
                ···tempS·0·_2.名称 = "caller"d;
                ···tempS·0·_2.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "__cyg_profile_func_exit"d, [···tempS·0·_1, ···tempS·0·_2], cast(修饰符_[][])(.Attr_NoUnwind));
        }
        case "__cyg_profile_func_enter"d: {
            名称及类型_ ···tempS·0·_3;
            {
                ···tempS·0·_3.名称 = "callee"d;
                ···tempS·0·_3.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_4;
            {
                ···tempS·0·_4.名称 = "caller"d;
                ···tempS·0·_4.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "__cyg_profile_func_exit"d, [···tempS·0·_3, ···tempS·0·_4], cast(修饰符_[][])(.Attr_NoUnwind));
        }
        case "_d_assert"d: {
            名称及类型_ ···tempS·0·_5;
            {
                ···tempS·0·_5.名称 = "file"d;
                ···tempS·0·_5.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_6;
            {
                ···tempS·0·_6.名称 = "line"d;
                ···tempS·0·_6.类型 = .uintTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_assert"d, [···tempS·0·_5, ···tempS·0·_6], cast(修饰符_[][])(.Attr_Cold_NoReturn));
        }
        case "_d_arraybounds"d: {
            名称及类型_ ···tempS·0·_7;
            {
                ···tempS·0·_7.名称 = "file"d;
                ···tempS·0·_7.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_8;
            {
                ···tempS·0·_8.名称 = "line"d;
                ···tempS·0·_8.类型 = .uintTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_arraybounds"d, [···tempS·0·_7, ···tempS·0·_8], cast(修饰符_[][])(.Attr_Cold_NoReturn));
        }
        case "_d_assert_msg"d: {
            名称及类型_ ···tempS·0·_9;
            {
                ···tempS·0·_9.名称 = "msg"d;
                ···tempS·0·_9.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_10;
            {
                ···tempS·0·_10.名称 = "file"d;
                ···tempS·0·_10.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_11;
            {
                ···tempS·0·_11.名称 = "line"d;
                ···tempS·0·_11.类型 = .uintTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_assert_msg"d, [
                ···tempS·0·_9,
                ···tempS·0·_10,
                ···tempS·0·_11
            ], cast(修饰符_[][])(.Attr_Cold_NoReturn));
        }
        case "_d_allocmemory"d: {
            名称及类型_ ···tempS·0·_12;
            {
                ···tempS·0·_12.名称 = "sz"d;
                ···tempS·0·_12.类型 = .sizeTy;
            }
            return .createFwdDecl(KSK.C_, .voidPtrTy, "_d_allocmemory"d, [···tempS·0·_12], cast(修饰符_[][])(.Attr_NoAlias));
        }
        case "_d_allocmemoryT"d: {
            名称及类型_ ···tempS·0·_13;
            {
                ···tempS·0·_13.名称 = "ti"d;
                ···tempS·0·_13.类型 = .typeInfoTy;
            }
            return .createFwdDecl(KSK.C_, .voidPtrTy, "_d_allocmemoryT"d, [···tempS·0·_13], cast(修饰符_[][])(.Attr_NoAlias));
        }
        case "_d_newarrayT"d: {
            名称及类型_ ···tempS·0·_14;
            {
                ···tempS·0·_14.名称 = "ti"d;
                ···tempS·0·_14.类型 = .typeInfoTy;
                ···tempS·0·_14.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_15;
            {
                ···tempS·0·_15.名称 = "length"d;
                ···tempS·0·_15.类型 = .sizeTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_newarrayT"d, [···tempS·0·_14, ···tempS·0·_15]);
        }
        case "_d_newarrayiT"d: {
            名称及类型_ ···tempS·0·_16;
            {
                ···tempS·0·_16.名称 = "ti"d;
                ···tempS·0·_16.类型 = .typeInfoTy;
                ···tempS·0·_16.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_17;
            {
                ···tempS·0·_17.名称 = "length"d;
                ···tempS·0·_17.类型 = .sizeTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_newarrayiT"d, [···tempS·0·_16, ···tempS·0·_17]);
        }
        case "_d_newarrayU"d: {
            名称及类型_ ···tempS·0·_18;
            {
                ···tempS·0·_18.名称 = "ti"d;
                ···tempS·0·_18.类型 = .typeInfoTy;
                ···tempS·0·_18.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_19;
            {
                ···tempS·0·_19.名称 = "length"d;
                ···tempS·0·_19.类型 = .sizeTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_newarrayU"d, [···tempS·0·_18, ···tempS·0·_19]);
        }
        case "_d_newarraymTX"d: {
            名称及类型_ ···tempS·0·_20;
            {
                ···tempS·0·_20.名称 = "ti"d;
                ···tempS·0·_20.类型 = .typeInfoTy;
                ···tempS·0·_20.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_21;
            {
                ···tempS·0·_21.名称 = "dims"d;
                ···tempS·0·_21.类型 = K.创建动态数组类型(.sizeTy);
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_newarraymTX"d, [···tempS·0·_20, ···tempS·0·_21]);
        }
        case "_d_newarraymiTX"d: {
            名称及类型_ ···tempS·0·_22;
            {
                ···tempS·0·_22.名称 = "ti"d;
                ···tempS·0·_22.类型 = .typeInfoTy;
                ···tempS·0·_22.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_23;
            {
                ···tempS·0·_23.名称 = "dims"d;
                ···tempS·0·_23.类型 = K.创建动态数组类型(.sizeTy);
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_newarraymiTX"d, [···tempS·0·_22, ···tempS·0·_23]);
        }
        case "_d_arraysetlengthT"d: {
            名称及类型_ ···tempS·0·_24;
            {
                ···tempS·0·_24.名称 = "ti"d;
                ···tempS·0·_24.类型 = .typeInfoTy;
                ···tempS·0·_24.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_25;
            {
                ···tempS·0·_25.名称 = "newlength"d;
                ···tempS·0·_25.类型 = .sizeTy;
            }
            名称及类型_ ···tempS·0·_26;
            {
                ···tempS·0·_26.名称 = "p"d;
                ···tempS·0·_26.类型 = .voidArrayPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_arraysetlengthT"d, [···tempS·0·_24, ···tempS·0·_25, ···tempS·0·_26]);
        }
        case "_d_arraysetlengthiT"d: {
            名称及类型_ ···tempS·0·_27;
            {
                ···tempS·0·_27.名称 = "ti"d;
                ···tempS·0·_27.类型 = .typeInfoTy;
                ···tempS·0·_27.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_28;
            {
                ···tempS·0·_28.名称 = "newlength"d;
                ···tempS·0·_28.类型 = .sizeTy;
            }
            名称及类型_ ···tempS·0·_29;
            {
                ···tempS·0·_29.名称 = "p"d;
                ···tempS·0·_29.类型 = .voidArrayPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_arraysetlengthiT"d, [···tempS·0·_27, ···tempS·0·_28, ···tempS·0·_29]);
        }
        case "_d_arrayappendcTX"d: {
            名称及类型_ ···tempS·0·_30;
            {
                ···tempS·0·_30.名称 = "ti"d;
                ···tempS·0·_30.类型 = .typeInfoTy;
                ···tempS·0·_30.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_31;
            {
                ···tempS·0·_31.名称 = "px"d // 引用;
                ;
                ···tempS·0·_31.类型 = .voidArrayTy;
                ···tempS·0·_31.修饰符 = 形参修饰符_.引用_;
            }
            名称及类型_ ···tempS·0·_32;
            {
                ···tempS·0·_32.名称 = "n"d;
                ···tempS·0·_32.类型 = .sizeTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_arrayappendcTX"d, [···tempS·0·_30, ···tempS·0·_31, ···tempS·0·_32]);
        }
        case "_d_arrayappendT"d: {
            名称及类型_ ···tempS·0·_33;
            {
                ···tempS·0·_33.名称 = "ti"d;
                ···tempS·0·_33.类型 = .typeInfoTy;
                ···tempS·0·_33.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_34;
            {
                ···tempS·0·_34.名称 = "x"d // 引用;
                ;
                ···tempS·0·_34.类型 = .voidArrayTy;
                ···tempS·0·_34.修饰符 = 形参修饰符_.引用_;
            }
            名称及类型_ ···tempS·0·_35;
            {
                ···tempS·0·_35.名称 = "y"d;
                ···tempS·0·_35.类型 = .voidArrayTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_arrayappendT"d, [···tempS·0·_33, ···tempS·0·_34, ···tempS·0·_35]);
        }
        case "_d_arrayappendcd"d: {
            名称及类型_ ···tempS·0·_36;
            {
                ···tempS·0·_36.名称 = "x"d;
                ···tempS·0·_36.类型 = .voidArrayTy;
                ···tempS·0·_36.修饰符 = 形参修饰符_.引用_;
            }
            名称及类型_ ···tempS·0·_37;
            {
                ···tempS·0·_37.名称 = "c"d // 引用;
                ;
                ···tempS·0·_37.类型 = .dcharTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_arrayappendcd"d, [···tempS·0·_36, ···tempS·0·_37]);
        }
        case "_d_arrayappendwd"d: {
            名称及类型_ ···tempS·0·_38;
            {
                ···tempS·0·_38.名称 = "x"d;
                ···tempS·0·_38.类型 = .voidArrayTy;
                ···tempS·0·_38.修饰符 = 形参修饰符_.引用_;
            }
            名称及类型_ ···tempS·0·_39;
            {
                ···tempS·0·_39.名称 = "c"d // 引用;
                ;
                ···tempS·0·_39.类型 = .dcharTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_arrayappendwd"d, [···tempS·0·_38, ···tempS·0·_39]);
        }
        case "_d_arraycatT"d: {
            名称及类型_ ···tempS·0·_40;
            {
                ···tempS·0·_40.名称 = "ti"d;
                ···tempS·0·_40.类型 = .typeInfoTy;
                ···tempS·0·_40.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_41;
            {
                ···tempS·0·_41.名称 = "x"d // 引用;
                ;
                ···tempS·0·_41.类型 = .voidArrayTy;
            }
            名称及类型_ ···tempS·0·_42;
            {
                ···tempS·0·_42.名称 = "y"d;
                ···tempS·0·_42.类型 = .voidArrayTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_arraycatT"d, [···tempS·0·_40, ···tempS·0·_41, ···tempS·0·_42]);
        }
        case "_d_arraycatnTX"d: {
            名称及类型_ ···tempS·0·_43;
            {
                ···tempS·0·_43.名称 = "ti"d;
                ···tempS·0·_43.类型 = .typeInfoTy;
                ···tempS·0·_43.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_44;
            {
                ···tempS·0·_44.名称 = "arrs"d // 引用;
                ;
                ···tempS·0·_44.类型 = K.创建动态数组类型(.voidArrayTy);
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_arraycatnTX"d, [···tempS·0·_43, ···tempS·0·_44]);
        }
        case "_d_newclass"d: {
            名称及类型_ ···tempS·0·_45;
            {
                ···tempS·0·_45.名称 = "ti"d;
                ···tempS·0·_45.类型 = .classInfoTy;
                ···tempS·0·_45.修饰符 = 形参修饰符_.常量_;
            }
            return .createFwdDecl(KSK.C_, .objectTy, "_d_newclass"d, [···tempS·0·_45]);
        }
        case "_d_allocclass"d: {
            名称及类型_ ···tempS·0·_46;
            {
                ···tempS·0·_46.名称 = "ti"d;
                ···tempS·0·_46.类型 = .classInfoTy;
                ···tempS·0·_46.修饰符 = 形参修饰符_.常量_;
            }
            return .createFwdDecl(KSK.C_, .objectTy, "_d_allocclass"d, [···tempS·0·_46], cast(修饰符_[][])(.Attr_NoAlias));
        }
        case "_d_newThrowable"d: {
            名称及类型_ ···tempS·0·_47;
            {
                ···tempS·0·_47.名称 = "ti"d;
                ···tempS·0·_47.类型 = .classInfoTy;
                ···tempS·0·_47.修饰符 = 形参修饰符_.常量_;
            }
            return .createFwdDecl(KSK.C_, .throwableTy, "_d_newThrowable"d, [···tempS·0·_47], cast(修饰符_[][])(.Attr_NoAlias));
        }
        case "_d_newitemT"d: {
            名称及类型_ ···tempS·0·_48;
            {
                ···tempS·0·_48.名称 = "ti"d;
                ···tempS·0·_48.类型 = .typeInfoTy;
            }
            return .createFwdDecl(KSK.C_, .voidPtrTy, "_d_newitemT"d, [···tempS·0·_48], cast(修饰符_[][])(.Attr_NoAlias));
        }
        case "_d_newitemiT"d: {
            名称及类型_ ···tempS·0·_49;
            {
                ···tempS·0·_49.名称 = "ti"d;
                ···tempS·0·_49.类型 = .typeInfoTy;
            }
            return .createFwdDecl(KSK.C_, .voidPtrTy, "_d_newitemiT"d, [···tempS·0·_49], cast(修饰符_[][])(.Attr_NoAlias));
        }
        case "_d_delarray_t"d: {
            名称及类型_ ···tempS·0·_50;
            {
                ···tempS·0·_50.名称 = "p"d;
                ···tempS·0·_50.类型 = .voidArrayPtrTy;
            }
            名称及类型_ ···tempS·0·_51;
            {
                ···tempS·0·_51.名称 = "ti"d;
                ···tempS·0·_51.类型 = .structTypeInfoTy;
                ···tempS·0·_51.修饰符 = 形参修饰符_.常量_;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_delarray_t"d, [···tempS·0·_50, ···tempS·0·_51]);
        }
        case "_d_delmemory"d: {
            名称及类型_ ···tempS·0·_52;
            {
                ···tempS·0·_52.名称 = "p"d;
                ···tempS·0·_52.类型 = K.创建指针类型(.voidPtrTy);
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_delmemory"d, [···tempS·0·_52]);
        }
        case "_d_delinterface"d: {
            名称及类型_ ···tempS·0·_53;
            {
                ···tempS·0·_53.名称 = "p"d;
                ···tempS·0·_53.类型 = K.创建指针类型(.voidPtrTy);
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_delinterface"d, [···tempS·0·_53]);
        }
        case "_d_callfinalizer"d: {
            名称及类型_ ···tempS·0·_54;
            {
                ···tempS·0·_54.名称 = "p"d;
                ···tempS·0·_54.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_callfinalizer"d, [···tempS·0·_54]);
        }
        case "_d_delclass"d: {
            名称及类型_ ···tempS·0·_55;
            {
                ···tempS·0·_55.名称 = "p"d;
                ···tempS·0·_55.类型 = K.创建指针类型(.objectTy);
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_delclass"d, [···tempS·0·_55]);
        }
        case "_d_delstruct"d: {
            名称及类型_ ···tempS·0·_56;
            {
                ···tempS·0·_56.名称 = "p"d;
                ···tempS·0·_56.类型 = K.创建指针类型(.voidPtrTy);
            }
            名称及类型_ ···tempS·0·_57;
            {
                ···tempS·0·_57.名称 = "inf"d;
                ···tempS·0·_57.类型 = .structTypeInfoTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_delstruct"d, [···tempS·0·_56, ···tempS·0·_57]);
        }
        case "_d_array_slice_copy"d: {
            名称及类型_ ···tempS·0·_58;
            {
                ···tempS·0·_58.名称 = "dst"d;
                ···tempS·0·_58.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_59;
            {
                ···tempS·0·_59.名称 = "dstlen"d;
                ···tempS·0·_59.类型 = .sizeTy;
            }
            名称及类型_ ···tempS·0·_60;
            {
                ···tempS·0·_60.名称 = "src"d;
                ···tempS·0·_60.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_61;
            {
                ···tempS·0·_61.名称 = "dstlen"d;
                ···tempS·0·_61.类型 = .sizeTy;
            }
            名称及类型_ ···tempS·0·_62;
            {
                ···tempS·0·_62.名称 = "elemsz"d;
                ···tempS·0·_62.类型 = .sizeTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_array_slice_copy"d, [···tempS·0·_58, ···tempS·0·_59, ···tempS·0·_60, ···tempS·0·_61, ···tempS·0·_62], cast(修饰符_[][])(.Attr_1_3_NoCapture));
        }
        case "_aApplycw1_stringTy"d: {
            名称及类型_ ···tempS·0·_63;
            {
                ···tempS·0·_63.名称 = "aa"d;
                ···tempS·0·_63.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_64;
            {
                ···tempS·0·_64.名称 = "dg"d;
                ···tempS·0·_64.类型 = .rt_dg1();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplycw1"d, [···tempS·0·_63, ···tempS·0·_64]);
        }
        case "_aApplycd1_stringTy"d: {
            名称及类型_ ···tempS·0·_65;
            {
                ···tempS·0·_65.名称 = "aa"d;
                ···tempS·0·_65.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_66;
            {
                ···tempS·0·_66.名称 = "dg"d;
                ···tempS·0·_66.类型 = .rt_dg1();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplycd1"d, [···tempS·0·_65, ···tempS·0·_66]);
        }
        case "_aApplyRcw1_stringTy"d: {
            名称及类型_ ···tempS·0·_67;
            {
                ···tempS·0·_67.名称 = "aa"d;
                ···tempS·0·_67.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_68;
            {
                ···tempS·0·_68.名称 = "dg"d;
                ···tempS·0·_68.类型 = .rt_dg1();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplyRcw1"d, [···tempS·0·_67, ···tempS·0·_68]);
        }
        case "_aApplyRcd1_stringTy"d: {
            名称及类型_ ···tempS·0·_69;
            {
                ···tempS·0·_69.名称 = "aa"d;
                ···tempS·0·_69.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_70;
            {
                ···tempS·0·_70.名称 = "dg"d;
                ···tempS·0·_70.类型 = .rt_dg1();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplyRcd1"d, [···tempS·0·_69, ···tempS·0·_70]);
        }
        case "_aApplycw1_wstringTy"d: {
            名称及类型_ ···tempS·0·_71;
            {
                ···tempS·0·_71.名称 = "aa"d;
                ···tempS·0·_71.类型 = .wstringTy;
            }
            名称及类型_ ···tempS·0·_72;
            {
                ···tempS·0·_72.名称 = "dg"d;
                ···tempS·0·_72.类型 = .rt_dg1();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplycw1"d, [···tempS·0·_71, ···tempS·0·_72]);
        }
        case "_aApplycd1_wstringTy"d: {
            名称及类型_ ···tempS·0·_73;
            {
                ···tempS·0·_73.名称 = "aa"d;
                ···tempS·0·_73.类型 = .wstringTy;
            }
            名称及类型_ ···tempS·0·_74;
            {
                ···tempS·0·_74.名称 = "dg"d;
                ···tempS·0·_74.类型 = .rt_dg1();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplycd1"d, [···tempS·0·_73, ···tempS·0·_74]);
        }
        case "_aApplyRcw1_wstringTy"d: {
            名称及类型_ ···tempS·0·_75;
            {
                ···tempS·0·_75.名称 = "aa"d;
                ···tempS·0·_75.类型 = .wstringTy;
            }
            名称及类型_ ···tempS·0·_76;
            {
                ···tempS·0·_76.名称 = "dg"d;
                ···tempS·0·_76.类型 = .rt_dg1();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplyRcw1"d, [···tempS·0·_75, ···tempS·0·_76]);
        }
        case "_aApplyRcd1_wstringTy"d: {
            名称及类型_ ···tempS·0·_77;
            {
                ···tempS·0·_77.名称 = "aa"d;
                ···tempS·0·_77.类型 = .wstringTy;
            }
            名称及类型_ ···tempS·0·_78;
            {
                ···tempS·0·_78.名称 = "dg"d;
                ···tempS·0·_78.类型 = .rt_dg1();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplyRcd1"d, [···tempS·0·_77, ···tempS·0·_78]);
        }
        case "_aApplycw1_dstringTy"d: {
            名称及类型_ ···tempS·0·_79;
            {
                ···tempS·0·_79.名称 = "aa"d;
                ···tempS·0·_79.类型 = .dstringTy;
            }
            名称及类型_ ···tempS·0·_80;
            {
                ···tempS·0·_80.名称 = "dg"d;
                ···tempS·0·_80.类型 = .rt_dg1();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplycw1"d, [···tempS·0·_79, ···tempS·0·_80]);
        }
        case "_aApplycd1_dstringTy"d: {
            名称及类型_ ···tempS·0·_81;
            {
                ···tempS·0·_81.名称 = "aa"d;
                ···tempS·0·_81.类型 = .dstringTy;
            }
            名称及类型_ ···tempS·0·_82;
            {
                ···tempS·0·_82.名称 = "dg"d;
                ···tempS·0·_82.类型 = .rt_dg1();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplycd1"d, [···tempS·0·_81, ···tempS·0·_82]);
        }
        case "_aApplyRcw1_dstringTy"d: {
            名称及类型_ ···tempS·0·_83;
            {
                ···tempS·0·_83.名称 = "aa"d;
                ···tempS·0·_83.类型 = .dstringTy;
            }
            名称及类型_ ···tempS·0·_84;
            {
                ···tempS·0·_84.名称 = "dg"d;
                ···tempS·0·_84.类型 = .rt_dg1();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplyRcw1"d, [···tempS·0·_83, ···tempS·0·_84]);
        }
        case "_aApplyRcd1_dstringTy"d: {
            名称及类型_ ···tempS·0·_85;
            {
                ···tempS·0·_85.名称 = "aa"d;
                ···tempS·0·_85.类型 = .dstringTy;
            }
            名称及类型_ ···tempS·0·_86;
            {
                ···tempS·0·_86.名称 = "dg"d;
                ···tempS·0·_86.类型 = .rt_dg1();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplyRcd1"d, [···tempS·0·_85, ···tempS·0·_86]);
        }
        case "_aApplycw2_stringTy"d: {
            名称及类型_ ···tempS·0·_87;
            {
                ···tempS·0·_87.名称 = "aa"d;
                ···tempS·0·_87.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_88;
            {
                ···tempS·0·_88.名称 = "dg"d;
                ···tempS·0·_88.类型 = .rt_dg2();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplycw2"d, [···tempS·0·_87, ···tempS·0·_88]);
        }
        case "_aApplycd2_stringTy"d: {
            名称及类型_ ···tempS·0·_89;
            {
                ···tempS·0·_89.名称 = "aa"d;
                ···tempS·0·_89.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_90;
            {
                ···tempS·0·_90.名称 = "dg"d;
                ···tempS·0·_90.类型 = .rt_dg2();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplycd2"d, [···tempS·0·_89, ···tempS·0·_90]);
        }
        case "_aApplyRcw2_stringTy"d: {
            名称及类型_ ···tempS·0·_91;
            {
                ···tempS·0·_91.名称 = "aa"d;
                ···tempS·0·_91.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_92;
            {
                ···tempS·0·_92.名称 = "dg"d;
                ···tempS·0·_92.类型 = .rt_dg2();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplyRcw2"d, [···tempS·0·_91, ···tempS·0·_92]);
        }
        case "_aApplyRcd2_stringTy"d: {
            名称及类型_ ···tempS·0·_93;
            {
                ···tempS·0·_93.名称 = "aa"d;
                ···tempS·0·_93.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_94;
            {
                ···tempS·0·_94.名称 = "dg"d;
                ···tempS·0·_94.类型 = .rt_dg2();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplyRcd2"d, [···tempS·0·_93, ···tempS·0·_94]);
        }
        case "_aApplycw2_wstringTy"d: {
            名称及类型_ ···tempS·0·_95;
            {
                ···tempS·0·_95.名称 = "aa"d;
                ···tempS·0·_95.类型 = .wstringTy;
            }
            名称及类型_ ···tempS·0·_96;
            {
                ···tempS·0·_96.名称 = "dg"d;
                ···tempS·0·_96.类型 = .rt_dg2();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplycw2"d, [···tempS·0·_95, ···tempS·0·_96]);
        }
        case "_aApplycd2_wstringTy"d: {
            名称及类型_ ···tempS·0·_97;
            {
                ···tempS·0·_97.名称 = "aa"d;
                ···tempS·0·_97.类型 = .wstringTy;
            }
            名称及类型_ ···tempS·0·_98;
            {
                ···tempS·0·_98.名称 = "dg"d;
                ···tempS·0·_98.类型 = .rt_dg2();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplycd2"d, [···tempS·0·_97, ···tempS·0·_98]);
        }
        case "_aApplyRcw2_wstringTy"d: {
            名称及类型_ ···tempS·0·_99;
            {
                ···tempS·0·_99.名称 = "aa"d;
                ···tempS·0·_99.类型 = .wstringTy;
            }
            名称及类型_ ···tempS·0·_100;
            {
                ···tempS·0·_100.名称 = "dg"d;
                ···tempS·0·_100.类型 = .rt_dg2();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplyRcw2"d, [···tempS·0·_99, ···tempS·0·_100]);
        }
        case "_aApplyRcd2_wstringTy"d: {
            名称及类型_ ···tempS·0·_101;
            {
                ···tempS·0·_101.名称 = "aa"d;
                ···tempS·0·_101.类型 = .wstringTy;
            }
            名称及类型_ ···tempS·0·_102;
            {
                ···tempS·0·_102.名称 = "dg"d;
                ···tempS·0·_102.类型 = .rt_dg2();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplyRcd2"d, [···tempS·0·_101, ···tempS·0·_102]);
        }
        case "_aApplycw2_dstringTy"d: {
            名称及类型_ ···tempS·0·_103;
            {
                ···tempS·0·_103.名称 = "aa"d;
                ···tempS·0·_103.类型 = .dstringTy;
            }
            名称及类型_ ···tempS·0·_104;
            {
                ···tempS·0·_104.名称 = "dg"d;
                ···tempS·0·_104.类型 = .rt_dg2();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplycw2"d, [···tempS·0·_103, ···tempS·0·_104]);
        }
        case "_aApplycd2_dstringTy"d: {
            名称及类型_ ···tempS·0·_105;
            {
                ···tempS·0·_105.名称 = "aa"d;
                ···tempS·0·_105.类型 = .dstringTy;
            }
            名称及类型_ ···tempS·0·_106;
            {
                ···tempS·0·_106.名称 = "dg"d;
                ···tempS·0·_106.类型 = .rt_dg2();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplycd2"d, [···tempS·0·_105, ···tempS·0·_106]);
        }
        case "_aApplyRcw2_dstringTy"d: {
            名称及类型_ ···tempS·0·_107;
            {
                ···tempS·0·_107.名称 = "aa"d;
                ···tempS·0·_107.类型 = .dstringTy;
            }
            名称及类型_ ···tempS·0·_108;
            {
                ···tempS·0·_108.名称 = "dg"d;
                ···tempS·0·_108.类型 = .rt_dg2();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplyRcw2"d, [···tempS·0·_107, ···tempS·0·_108]);
        }
        case "_aApplyRcd2_dstringTy"d: {
            名称及类型_ ···tempS·0·_109;
            {
                ···tempS·0·_109.名称 = "aa"d;
                ···tempS·0·_109.类型 = .dstringTy;
            }
            名称及类型_ ···tempS·0·_110;
            {
                ···tempS·0·_110.名称 = "dg"d;
                ···tempS·0·_110.类型 = .rt_dg2();
            }
            return .createFwdDecl(KSK.C_, .sizeTy, "_aApplyRcd2"d, [···tempS·0·_109, ···tempS·0·_110]);
        }
        case "_d_arrayassign_l"d: {
            名称及类型_ ···tempS·0·_111;
            {
                ···tempS·0·_111.名称 = "ti"d;
                ···tempS·0·_111.类型 = .typeInfoTy;
            }
            名称及类型_ ···tempS·0·_112;
            {
                ···tempS·0·_112.名称 = "src"d;
                ···tempS·0·_112.类型 = .voidArrayTy;
            }
            名称及类型_ ···tempS·0·_113;
            {
                ···tempS·0·_113.名称 = "dst"d;
                ···tempS·0·_113.类型 = .voidArrayTy;
            }
            名称及类型_ ···tempS·0·_114;
            {
                ···tempS·0·_114.名称 = "ptmp"d;
                ···tempS·0·_114.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_arrayassign_l"d, [···tempS·0·_111, ···tempS·0·_112, ···tempS·0·_113, ···tempS·0·_114]);
        }
        case "_d_arrayassign_r"d: {
            名称及类型_ ···tempS·0·_115;
            {
                ···tempS·0·_115.名称 = "ti"d;
                ···tempS·0·_115.类型 = .typeInfoTy;
            }
            名称及类型_ ···tempS·0·_116;
            {
                ···tempS·0·_116.名称 = "src"d;
                ···tempS·0·_116.类型 = .voidArrayTy;
            }
            名称及类型_ ···tempS·0·_117;
            {
                ···tempS·0·_117.名称 = "dst"d;
                ···tempS·0·_117.类型 = .voidArrayTy;
            }
            名称及类型_ ···tempS·0·_118;
            {
                ···tempS·0·_118.名称 = "ptmp"d;
                ···tempS·0·_118.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_arrayassign_r"d, [···tempS·0·_115, ···tempS·0·_116, ···tempS·0·_117, ···tempS·0·_118]);
        }
        case "_d_arrayctor"d: {
            名称及类型_ ···tempS·0·_119;
            {
                ···tempS·0·_119.名称 = "ti"d;
                ···tempS·0·_119.类型 = .typeInfoTy;
            }
            名称及类型_ ···tempS·0·_120;
            {
                ···tempS·0·_120.名称 = "from"d;
                ···tempS·0·_120.类型 = .voidArrayTy;
            }
            名称及类型_ ···tempS·0·_121;
            {
                ···tempS·0·_121.名称 = "to"d;
                ···tempS·0·_121.类型 = .voidArrayTy;
            }
            return .createFwdDecl(KSK.C_, .voidArrayTy, "_d_arrayctor"d, [···tempS·0·_119, ···tempS·0·_120, ···tempS·0·_121]);
        }
        case "_d_arraysetassign"d: {
            名称及类型_ ···tempS·0·_122;
            {
                ···tempS·0·_122.名称 = "p"d;
                ···tempS·0·_122.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_123;
            {
                ···tempS·0·_123.名称 = "value"d;
                ···tempS·0·_123.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_124;
            {
                ···tempS·0·_124.名称 = "count"d;
                ···tempS·0·_124.类型 = .intTy;
            }
            名称及类型_ ···tempS·0·_125;
            {
                ···tempS·0·_125.名称 = "ti"d;
                ···tempS·0·_125.类型 = .typeInfoTy;
            }
            return .createFwdDecl(KSK.C_, .voidPtrTy, "_d_arraysetassign"d, [···tempS·0·_122, ···tempS·0·_123, ···tempS·0·_124, ···tempS·0·_125], cast(修饰符_[][])(.Attr_NoAlias));
        }
        case "_d_arraysetctor"d: {
            名称及类型_ ···tempS·0·_126;
            {
                ···tempS·0·_126.名称 = "p"d;
                ···tempS·0·_126.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_127;
            {
                ···tempS·0·_127.名称 = "value"d;
                ···tempS·0·_127.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_128;
            {
                ···tempS·0·_128.名称 = "count"d;
                ···tempS·0·_128.类型 = .intTy;
            }
            名称及类型_ ···tempS·0·_129;
            {
                ···tempS·0·_129.名称 = "ti"d;
                ···tempS·0·_129.类型 = .typeInfoTy;
            }
            return .createFwdDecl(KSK.C_, .voidPtrTy, "_d_arraysetctor"d, [···tempS·0·_126, ···tempS·0·_127, ···tempS·0·_128, ···tempS·0·_129], cast(修饰符_[][])(.Attr_NoAlias));
        }
        case "_d_interface_cast"d: {
            名称及类型_ ···tempS·0·_130;
            {
                ···tempS·0·_130.名称 = "p"d;
                ···tempS·0·_130.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_131;
            {
                ···tempS·0·_131.名称 = "c"d;
                ···tempS·0·_131.类型 = .classInfoTy;
            }
            return .createFwdDecl(KSK.C_, .voidPtrTy, "_d_interface_cast"d, [···tempS·0·_130, ···tempS·0·_131], cast(修饰符_[][])(.Attr_ReadOnly_NoUnwind));
        }
        case "_d_dynamic_cast"d: {
            名称及类型_ ···tempS·0·_132;
            {
                ···tempS·0·_132.名称 = "o"d;
                ···tempS·0·_132.类型 = .objectTy;
            }
            名称及类型_ ···tempS·0·_133;
            {
                ···tempS·0·_133.名称 = "c"d;
                ···tempS·0·_133.类型 = .classInfoTy;
            }
            return .createFwdDecl(KSK.C_, .voidPtrTy, "_d_dynamic_cast"d, [···tempS·0·_132, ···tempS·0·_133], cast(修饰符_[][])(.Attr_ReadOnly_NoUnwind));
        }
        case "_adEq2"d: {
            名称及类型_ ···tempS·0·_134;
            {
                ···tempS·0·_134.名称 = "a1"d;
                ···tempS·0·_134.类型 = .voidArrayTy;
            }
            名称及类型_ ···tempS·0·_135;
            {
                ···tempS·0·_135.名称 = "a2"d;
                ···tempS·0·_135.类型 = .voidArrayTy;
            }
            名称及类型_ ···tempS·0·_136;
            {
                ···tempS·0·_136.名称 = "ti"d;
                ···tempS·0·_136.类型 = .typeInfoTy;
            }
            return .createFwdDecl(KSK.C_, .intTy, "_adEq2"d, [···tempS·0·_134, ···tempS·0·_135, ···tempS·0·_136], cast(修饰符_[][])(.Attr_ReadOnly));
        }
        case "_aaGetY"d: {
            名称及类型_ ···tempS·0·_137;
            {
                ···tempS·0·_137.名称 = "aa"d;
                ···tempS·0·_137.类型 = K.创建指针类型(.aaTy);
            }
            名称及类型_ ···tempS·0·_138;
            {
                ···tempS·0·_138.名称 = "aati"d;
                ···tempS·0·_138.类型 = .voidArrayTy;
                ···tempS·0·_138.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_139;
            {
                ···tempS·0·_139.名称 = "valuesize"d;
                ···tempS·0·_139.类型 = .typeInfoTy;
                ···tempS·0·_139.修饰符 = 形参修饰符_.输入_;
            }
            名称及类型_ ···tempS·0·_140;
            {
                ···tempS·0·_140.名称 = "pkey"d;
                ···tempS·0·_140.类型 = .typeInfoTy;
                ···tempS·0·_140.修饰符 = 形参修饰符_.输入_;
            }
            return .createFwdDecl(KSK.C_, .voidPtrTy, "_aaGetY"d, [···tempS·0·_137, ···tempS·0·_138, ···tempS·0·_139, ···tempS·0·_140], cast(修饰符_[][])(.Attr_1_4_NoCapture));
        }
        case "_aaInX"d: {
            名称及类型_ ···tempS·0·_141;
            {
                ···tempS·0·_141.名称 = "aa"d;
                ···tempS·0·_141.类型 = .aaTy;
                ···tempS·0·_141.修饰符 = 形参修饰符_.输入_ | 形参修饰符_.输出_;
            }
            名称及类型_ ···tempS·0·_142;
            {
                ···tempS·0·_142.名称 = "keyti"d;
                ···tempS·0·_142.类型 = .typeInfoTy;
                ···tempS·0·_142.修饰符 = 形参修饰符_.输入_;
            }
            名称及类型_ ···tempS·0·_143;
            {
                ···tempS·0·_143.名称 = "pkey"d;
                ···tempS·0·_143.类型 = .voidPtrTy;
                ···tempS·0·_143.修饰符 = 形参修饰符_.输入_;
            }
            return .createFwdDecl(KSK.C_, .voidPtrTy, "_aaInX"d, [···tempS·0·_141, ···tempS·0·_142, ···tempS·0·_143], cast(修饰符_[][])(.Attr_ReadOnly_1_3_NoCapture));
        }
        case "_aaDelX"d: {
            名称及类型_ ···tempS·0·_144;
            {
                ···tempS·0·_144.名称 = "aa"d;
                ···tempS·0·_144.类型 = .aaTy;
            }
            名称及类型_ ···tempS·0·_145;
            {
                ···tempS·0·_145.名称 = "keyti"d;
                ···tempS·0·_145.类型 = .typeInfoTy;
                ···tempS·0·_145.修饰符 = 形参修饰符_.输入_;
            }
            名称及类型_ ···tempS·0·_146;
            {
                ···tempS·0·_146.名称 = "pkey"d;
                ···tempS·0·_146.类型 = .voidPtrTy;
                ···tempS·0·_146.修饰符 = 形参修饰符_.输入_;
            }
            return .createFwdDecl(KSK.C_, .boolTy, "_aaDelX"d, [···tempS·0·_144, ···tempS·0·_145, ···tempS·0·_146], cast(修饰符_[][])(.Attr_1_3_NoCapture));
        }
        case "_aaEqual"d: {
            名称及类型_ ···tempS·0·_147;
            {
                ···tempS·0·_147.名称 = "tiRaw"d;
                ···tempS·0·_147.类型 = .typeInfoTy;
                ···tempS·0·_147.修饰符 = 形参修饰符_.输入_;
            }
            名称及类型_ ···tempS·0·_148;
            {
                ···tempS·0·_148.名称 = "e1"d;
                ···tempS·0·_148.类型 = .aaTy;
                ···tempS·0·_148.修饰符 = 形参修饰符_.输入_;
            }
            名称及类型_ ···tempS·0·_149;
            {
                ···tempS·0·_149.名称 = "e2"d;
                ···tempS·0·_149.类型 = .aaTy;
                ···tempS·0·_149.修饰符 = 形参修饰符_.输入_;
            }
            return .createFwdDecl(KSK.C_, .intTy, "_aaEqual"d, [···tempS·0·_147, ···tempS·0·_148, ···tempS·0·_149], cast(修饰符_[][])(.Attr_1_2_NoCapture));
        }
        case "_d_assocarrayliteralTX"d: {
            名称及类型_ ···tempS·0·_150;
            {
                ···tempS·0·_150.名称 = "ti"d;
                ···tempS·0·_150.类型 = .aaTypeInfoTy;
                ···tempS·0·_150.修饰符 = 形参修饰符_.常量_;
            }
            名称及类型_ ···tempS·0·_151;
            {
                ···tempS·0·_151.名称 = "keys"d;
                ···tempS·0·_151.类型 = .voidArrayTy;
            }
            名称及类型_ ···tempS·0·_152;
            {
                ···tempS·0·_152.名称 = "values"d;
                ···tempS·0·_152.类型 = .voidArrayTy;
            }
            return .createFwdDecl(KSK.C_, .aaTy, "_d_assocarrayliteralTX"d, [···tempS·0·_150, ···tempS·0·_151, ···tempS·0·_152]);
        }
        case "_d_throw_exception"d: {
            名称及类型_ ···tempS·0·_153;
            {
                ···tempS·0·_153.名称 = "o"d;
                ···tempS·0·_153.类型 = .throwableTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_throw_exception"d, [···tempS·0·_153], cast(修饰符_[][])(.Attr_Cold_NoReturn));
        }
        case "__CxxFrameHandler3"d: {
            名称及类型_ ···tempS·0·_154;
            {
                ···tempS·0·_154.名称 = "ExceptionRecord"d;
                ···tempS·0·_154.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_155;
            {
                ···tempS·0·_155.名称 = "EstablisherFrame"d;
                ···tempS·0·_155.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_156;
            {
                ···tempS·0·_156.名称 = "ContextRecord"d;
                ···tempS·0·_156.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_157;
            {
                ···tempS·0·_157.名称 = "DispatcherContext"d;
                ···tempS·0·_157.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .intTy, "__CxxFrameHandler3"d, [···tempS·0·_154, ···tempS·0·_155, ···tempS·0·_156, ···tempS·0·_157]);
        }
        case "_d_eh_personality_MSVC"d: {
            名称及类型_ ···tempS·0·_158;
            {
                ···tempS·0·_158.名称 = "ExceptionRecord"d;
                ···tempS·0·_158.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_159;
            {
                ···tempS·0·_159.名称 = "EstablisherFrame"d;
                ···tempS·0·_159.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_160;
            {
                ···tempS·0·_160.名称 = "ContextRecord"d;
                ···tempS·0·_160.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_161;
            {
                ···tempS·0·_161.名称 = "DispatcherContext"d;
                ···tempS·0·_161.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .intTy, "_d_eh_personality_MSVC"d, [···tempS·0·_158, ···tempS·0·_159, ···tempS·0·_160, ···tempS·0·_161]);
        }
        case "_d_eh_personality_arm"d: {
            名称及类型_ ···tempS·0·_162;
            {
                ···tempS·0·_162.名称 = "state"d;
                ···tempS·0·_162.类型 = .intTy;
            }
            名称及类型_ ···tempS·0·_163;
            {
                ···tempS·0·_163.名称 = "ucb"d;
                ···tempS·0·_163.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_164;
            {
                ···tempS·0·_164.名称 = "context"d;
                ···tempS·0·_164.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .intTy, "_d_eh_personality_arm"d, [···tempS·0·_162, ···tempS·0·_163, ···tempS·0·_164]);
        }
        case "_d_eh_personality"d: {
            名称及类型_ ···tempS·0·_165;
            {
                ···tempS·0·_165.名称 = "state"d;
                ···tempS·0·_165.类型 = .intTy;
            }
            名称及类型_ ···tempS·0·_166;
            {
                ···tempS·0·_166.名称 = "actions"d;
                ···tempS·0·_166.类型 = .intTy;
            }
            名称及类型_ ···tempS·0·_167;
            {
                ···tempS·0·_167.名称 = "eh_class"d;
                ···tempS·0·_167.类型 = .ulongTy;
            }
            名称及类型_ ···tempS·0·_168;
            {
                ···tempS·0·_168.名称 = "eh_info"d;
                ···tempS·0·_168.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_169;
            {
                ···tempS·0·_169.名称 = "context"d;
                ···tempS·0·_169.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .intTy, "_d_eh_personality"d, [···tempS·0·_165, ···tempS·0·_166, ···tempS·0·_167, ···tempS·0·_168, ···tempS·0·_169]);
        }
        case "_d_enter_cleanup"d: {
            名称及类型_ ···tempS·0·_170;
            {
                ···tempS·0·_170.名称 = "frame"d;
                ···tempS·0·_170.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .boolTy, "_d_enter_cleanup"d, [···tempS·0·_170]);
        }
        case "_d_enter_cleanup_V"d: {
            名称及类型_ ···tempS·0·_171;
            {
                ···tempS·0·_171.名称 = "frame"d;
                ···tempS·0·_171.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_enter_cleanup_V"d, [···tempS·0·_171]);
        }
        case "_d_eh_enter_catch_MSVC"d: {
            名称及类型_ ···tempS·0·_172;
            {
                ···tempS·0·_172.名称 = "exception"d;
                ···tempS·0·_172.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_173;
            {
                ···tempS·0·_173.名称 = "catchType"d;
                ···tempS·0·_173.类型 = .classInfoTy;
            }
            return .createFwdDecl(KSK.C_, .throwableTy, "_d_eh_enter_catch_MSVC"d, [···tempS·0·_172, ···tempS·0·_173]);
        }
        case "_Unwind_SjLj_Resume"d: {
            名称及类型_ ···tempS·0·_174;
            {
                ···tempS·0·_174.名称 = "ptr"d;
                ···tempS·0·_174.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_Unwind_SjLj_Resume"d, [···tempS·0·_174], cast(修饰符_[][])(.Attr_Cold_NoReturn));
        }
        case "_d_eh_resume_unwind"d: {
            名称及类型_ ···tempS·0·_175;
            {
                ···tempS·0·_175.名称 = "ptr"d;
                ···tempS·0·_175.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_eh_resume_unwind"d, [···tempS·0·_175], cast(修饰符_[][])(.Attr_Cold_NoReturn));
        }
        case "_Unwind_Resume"d: {
            名称及类型_ ···tempS·0·_176;
            {
                ···tempS·0·_176.名称 = "ptr"d;
                ···tempS·0·_176.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_Unwind_Resume"d, [···tempS·0·_176], cast(修饰符_[][])(.Attr_Cold_NoReturn));
        }
        case "_d_eh_enter_catch"d: {
            名称及类型_ ···tempS·0·_177;
            {
                ···tempS·0·_177.名称 = "ptr"d;
                ···tempS·0·_177.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .throwableTy, "_d_eh_enter_catch"d, [···tempS·0·_177], cast(修饰符_[][])(.Attr_NoUnwind));
        }
        case "__cxa_begin_catch"d: {
            名称及类型_ ···tempS·0·_178;
            {
                ···tempS·0·_178.名称 = "ptr"d;
                ···tempS·0·_178.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidPtrTy, "__cxa_begin_catch"d, [···tempS·0·_178], cast(修饰符_[][])(.Attr_NoUnwind));
        }
        case "_D9invariant12_d_invariantFC6ObjectZv"d: {
            名称及类型_ ···tempS·0·_179;
            {
                ···tempS·0·_179.名称 = "o"d;
                ···tempS·0·_179.类型 = .objectTy;
            }
            return .createFwdDecl(KSK.D_, .voidTy, "\\01_D9invariant12_d_invariantFC6ObjectZv"d, [···tempS·0·_179]);
        }
        case "_d_dso_registry"d: {
            名称及类型_ ···tempS·0·_180;
            {
                ···tempS·0·_180.名称 = "data"d;
                ···tempS·0·_180.类型 = .voidPtrTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_dso_registry"d, [···tempS·0·_180]);
        }
        case "_d_cover_register2"d: {
            名称及类型_ ···tempS·0·_181;
            {
                ···tempS·0·_181.名称 = "filename"d;
                ···tempS·0·_181.类型 = .stringTy;
            }
            名称及类型_ ···tempS·0·_182;
            {
                ···tempS·0·_182.名称 = "valid"d;
                ···tempS·0·_182.类型 = K.创建动态数组类型(.sizeTy);
            }
            名称及类型_ ···tempS·0·_183;
            {
                ···tempS·0·_183.名称 = "data"d;
                ···tempS·0·_183.类型 = K.创建动态数组类型(.uintTy);
            }
            名称及类型_ ···tempS·0·_184;
            {
                ···tempS·0·_184.名称 = "minPercent"d;
                ···tempS·0·_184.类型 = .ubyteTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "_d_cover_register2"d, [···tempS·0·_181, ···tempS·0·_182, ···tempS·0·_183, ···tempS·0·_184]);
        }
        case "trace_pro"d: {
            名称及类型_ ···tempS·0·_185;
            {
                ···tempS·0·_185.名称 = "id"d;
                ···tempS·0·_185.类型 = .stringTy;
            }
            return .createFwdDecl(KSK.C_, .voidTy, "trace_pro"d, [···tempS·0·_185]);
        }
        case "_c_trace_epi"d: {
            return .createFwdDecl(KSK.C_, .voidTy, "_c_trace_epi"d);
        }
        case "memcmp"d: {
            名称及类型_ ···tempS·0·_186;
            {
                ···tempS·0·_186.名称 = "s1"d;
                ···tempS·0·_186.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_187;
            {
                ···tempS·0·_187.名称 = "s2"d;
                ···tempS·0·_187.类型 = .voidPtrTy;
            }
            名称及类型_ ···tempS·0·_188;
            {
                ···tempS·0·_188.名称 = "n"d;
                ···tempS·0·_188.类型 = .sizeTy;
            }
            return .createFwdDecl(KSK.C_, .intTy, "memcmp"d, [···tempS·0·_186, ···tempS·0·_187, ···tempS·0·_188], cast(修饰符_[][])(.Attr_ReadOnly_NoUnwind_1_2_NoCapture));
        }
        default: break;
    }
    return ··null!(函数声明_);
}
类型_ rt_dg1() {
    ··Klang节点_.Klang节点_ pt = 实例化类型(.voidPtrTy, .当前打印环境);
    获取合成节点扩展(pt).解析类型 = .voidPtrTy;
    形参声明_ ptd = fc.创建形参声明(fc.创建标识符("arg_1"d), pt);
    ptd.符号 = new 符号_((cast(ulong)(符号标志_.形参声明_)), "arg_1"d);
    ptd.符号.值声明 = ptd;
    ptd.符号.声明组 = [ptd];
    (cast(符号_)(ptd.符号)).类型 = .voidPtrTy;
    ··Klang节点_.Klang节点_ ind = 实例化类型(.intTy, .当前打印环境);
    函数类型节点_ Td = fc.创建函数类型(fc.f·创建节点数组!(形参声明_)([ptd], false), ind);
    符号_ 符号 = new 符号_((cast(ulong)(符号标志_.签名_)), 内部符号名_.调用_);
    符号.值声明 = Td;
    符号.声明组 = [Td];
    Td.符号 = 符号;
    符号.类型 = K.创建函数类型(符号);
    符号.类型.复合标志 |= 复合标志_.委托_;
    获取合成节点扩展(Td).解析类型 = 符号.类型;
    return 符号.类型;
}
类型_ rt_dg2() {
    ··Klang节点_.Klang节点_ pt = 实例化类型(.voidPtrTy, .当前打印环境);
    获取合成节点扩展(pt).解析类型 = .voidPtrTy;
    形参声明_ ptd = fc.创建形参声明(fc.创建标识符("arg_1"d), pt);
    ptd.符号 = new 符号_((cast(ulong)(符号标志_.形参声明_)), "arg_1"d);
    ptd.符号.值声明 = ptd;
    ptd.符号.声明组 = [ptd];
    (cast(符号_)(ptd.符号)).类型 = .voidPtrTy;
    形参声明_ ptd2 = fc.创建形参声明(fc.创建标识符("arg_2"d), pt);
    ptd2.符号 = new 符号_((cast(ulong)(符号标志_.形参声明_)), "arg_2"d);
    ptd2.符号.值声明 = ptd2;
    ptd2.符号.声明组 = [ptd2];
    (cast(符号_)(ptd2.符号)).类型 = .voidPtrTy;
    ··Klang节点_.Klang节点_ ind = 实例化类型(.intTy, .当前打印环境);
    函数类型节点_ Td = fc.创建函数类型(fc.f·创建节点数组!(形参声明_)([ptd, ptd2], false), ind);
    符号_ 符号 = new 符号_((cast(ulong)(符号标志_.签名_)), 内部符号名_.调用_);
    符号.值声明 = Td;
    符号.声明组 = [Td];
    Td.符号 = 符号;
    符号.类型 = K.创建函数类型(符号);
    符号.类型.复合标志 |= 复合标志_.委托_;
    获取合成节点扩展(Td).解析类型 = 符号.类型;
    return 符号.类型;
}
标识符修饰符_[][] 创建特性组(标识符修饰符_[][] atts, int 标志, 标识符修饰符_[] 修饰符) {
    标识符修饰符_[][] arr = atts[0 .. $];
    if (arr.length < 标志 + 1) {
        arr.length = 标志 + 1;
    }
    if (arr[标志] !is ··null!(标识符修饰符_[])) {
        arr[标志] = .追加!(标识符修饰符_)(arr[标志], 修饰符);
    }
    else {
        arr[标志] = 修饰符;
    }
    return arr;
}
外部修饰符声明_ 创建连接修饰符(KSK 修饰符) {
    switch (修饰符) {
        case KSK.C_: {
            return fc.创建外部修饰符声明((cast(修饰符_)(fc.转为令牌(KSK.C_))));
        }
        case KSK.D_: {
            return fc.创建外部修饰符声明((cast(修饰符_)(fc.转为令牌(KSK.D_))));
        }
        default: break;
    }
    return ··null!(外部修饰符声明_);
}
函数声明_ createFwdDecl(KSK 连接标志, 类型_ 返回类型, dstring 名称, 名称及类型_[] 形参组 = ··null!(名称及类型_[]), 修饰符_[][] 特性 = ··null!(修饰符_[][])) {
    外部修饰符声明_ 连接 = .创建连接修饰符(连接标志);
    ··Klang节点_.Klang节点_ RT = 实例化类型(返回类型, .当前打印环境);
    ··Klang节点_.Klang标识符_ 函数名称 = fc.创建标识符(名称);
    形参声明_[] 形参;
    if (形参组 !is ··null!(名称及类型_[])) {
        形参 = 映射!(名称及类型_, 形参声明_)(形参组, (名称及类型_ p, size_t i) {
            if (p.修饰符 != 形参修饰符_.无_) {
                if (特性 is ··null!(修饰符_[][])) {
                    特性 = 创建数组!(修饰符_[])();
                }
                if (特性.length < i + 3) {
                    特性.length = i + 3;
                }
                if (特性[i + 2] is ··null!(修饰符_[])) {
                    特性[i + 2] = 创建数组!(修饰符_)();
                }
                if ((p.修饰符 & 形参修饰符_.引用_) != 0) {
                    .追加!(修饰符_)(特性[i + 2], fc.创建标识符修饰符("ref"d));
                }
                if ((p.修饰符 & 形参修饰符_.输入_) != 0 && (p.修饰符 & 形参修饰符_.输出_) != 0) {
                    .追加!(修饰符_)(特性[i + 2], fc.创建标识符修饰符("inout"d));
                }
                else if ((p.修饰符 & 形参修饰符_.输入_) != 0) {
                    .追加!(修饰符_)(特性[i + 2], fc.创建标识符修饰符("in"d));
                }
                else if ((p.修饰符 & 形参修饰符_.输出_) != 0) {
                    .追加!(修饰符_)(特性[i + 2], fc.创建标识符修饰符("out"d));
                }
                if ((p.修饰符 & 形参修饰符_.常量_) != 0) {
                    .追加!(修饰符_)(特性[i + 2], fc.创建标识符修饰符("const"d));
                }
            }
            if ((特性 !is ··null!(修饰符_[][])) && 特性.length > i + 2 && (特性[i + 2] !is ··null!(修饰符_[]))) {
                修饰符_[] 当前特性 = 特性[i + 2];
                return fc.创建形参声明(fc.创建标识符(p.名称), 实例化类型(p.类型, .当前打印环境), fc.f·创建节点数组!(修饰符_)((cast(修饰符_[])(当前特性)), false));
            }
            else {
                return fc.创建形参声明(fc.创建标识符(p.名称), 实例化类型(p.类型, .当前打印环境));
            }
        });
    }
    修饰符_[] 函数特性 = 创建数组!(修饰符_)();
    .追加!(修饰符_)(函数特性, (cast(修饰符_)(fc.转为令牌(KSK.声明_))));
    if ((特性 !is ··null!(修饰符_[][])) && 特性.length > 0) {
        函数特性 = .追加!(修饰符_)(函数特性, 特性[0]);
    }
    if ((特性 !is ··null!(修饰符_[][])) && 特性.length > 1) {
        函数特性 = .追加!(修饰符_)(函数特性, 特性[1]);
    }
    return fc.创建函数声明(函数名称, ··null!(··节点_.节点数组_!(··Klang节点_.类型形参_)), 形参 ? fc.f·创建节点数组!(形参声明_)(形参, false) : ··null!(··节点_.节点数组_!(形参声明_)), RT, ··null!(··节点_.节点_), fc.f·创建节点数组!(修饰符_)(函数特性, false));
}
标识符修饰符_ 获取特性标识符外部(dstring 名称) {
    switch (名称) {
        case "AlwaysInline"d: {
            return fc.创建标识符修饰符("alwaysinline"d);
        }
        case "ArgMemOnly"d: {
            return fc.创建标识符修饰符("argmemonly"d);
        }
        case "Builtin"d: {
            return fc.创建标识符修饰符("builtin"d);
        }
        case "Cold"d: {
            return fc.创建标识符修饰符("cold"d);
        }
        case "Convergent"d: {
            return fc.创建标识符修饰符("convergent"d);
        }
        case "DisableSanitizerInstrumentation"d: {
            return fc.创建标识符修饰符("disable_sanitizer_instrumentation"d);
        }
        case "Hot"d: {
            return fc.创建标识符修饰符("hot"d);
        }
        case "ImmArg"d: {
            return fc.创建标识符修饰符("immarg"d);
        }
        case "InReg"d: {
            return fc.创建标识符修饰符("inreg"d);
        }
        case "InaccessibleMemOnly"d: {
            return fc.创建标识符修饰符("inaccessiblememonly"d);
        }
        case "InaccessibleMemOrArgMemOnly"d: {
            return fc.创建标识符修饰符("inaccessiblemem_or_argmemonly"d);
        }
        case "InlineHint"d: {
            return fc.创建标识符修饰符("inlinehint"d);
        }
        case "JumpTable"d: {
            return fc.创建标识符修饰符("jumptable"d);
        }
        case "MinSize"d: {
            return fc.创建标识符修饰符("minsize"d);
        }
        case "MustProgress"d: {
            return fc.创建标识符修饰符("mustprogress"d);
        }
        case "Naked"d: {
            return fc.创建标识符修饰符("naked"d);
        }
        case "Nest"d: {
            return fc.创建标识符修饰符("nest"d);
        }
        case "NoAlias"d: {
            return fc.创建标识符修饰符("noalias"d);
        }
        case "NoBuiltin"d: {
            return fc.创建标识符修饰符("nobuiltin"d);
        }
        case "NoCallback"d: {
            return fc.创建标识符修饰符("nocallback"d);
        }
        case "NoCapture"d: {
            return fc.创建标识符修饰符("nocapture"d);
        }
        case "NoCfCheck"d: {
            return fc.创建标识符修饰符("nocf_check"d);
        }
        case "NoDuplicate"d: {
            return fc.创建标识符修饰符("noduplicate"d);
        }
        case "NoFree"d: {
            return fc.创建标识符修饰符("nofree"d);
        }
        case "NoImplicitFloat"d: {
            return fc.创建标识符修饰符("noimplicitfloat"d);
        }
        case "NoInline"d: {
            return fc.创建标识符修饰符("noinline"d);
        }
        case "NoMerge"d: {
            return fc.创建标识符修饰符("nomerge"d);
        }
        case "NoProfile"d: {
            return fc.创建标识符修饰符("noprofile"d);
        }
        case "NoRecurse"d: {
            return fc.创建标识符修饰符("norecurse"d);
        }
        case "NoRedZone"d: {
            return fc.创建标识符修饰符("noredzone"d);
        }
        case "NoReturn"d: {
            return fc.创建标识符修饰符("noreturn"d);
        }
        case "NoSanitizeCoverage"d: {
            return fc.创建标识符修饰符("nosanitize_coverage"d);
        }
        case "NoSync"d: {
            return fc.创建标识符修饰符("nosync"d);
        }
        case "NoUndef"d: {
            return fc.创建标识符修饰符("noundef"d);
        }
        case "NoUnwind"d: {
            return fc.创建标识符修饰符("nounwind"d);
        }
        case "NonLazyBind"d: {
            return fc.创建标识符修饰符("nonlazybind"d);
        }
        case "NonNull"d: {
            return fc.创建标识符修饰符("nonnull"d);
        }
        case "NullPointerIsValid"d: {
            return fc.创建标识符修饰符("null_pointer_is_valid"d);
        }
        case "OptForFuzzing"d: {
            return fc.创建标识符修饰符("optforfuzzing"d);
        }
        case "OptimizeForSize"d: {
            return fc.创建标识符修饰符("optsize"d);
        }
        case "OptimizeNone"d: {
            return fc.创建标识符修饰符("optnone"d);
        }
        case "ReadNone"d: {
            return fc.创建标识符修饰符("readnone"d);
        }
        case "ReadOnly"d: {
            return fc.创建标识符修饰符("readonly"d);
        }
        case "Returned"d: {
            return fc.创建标识符修饰符("returned"d);
        }
        case "ReturnsTwice"d: {
            return fc.创建标识符修饰符("returns_twice"d);
        }
        case "SExt"d: {
            return fc.创建标识符修饰符("signext"d);
        }
        case "SafeStack"d: {
            return fc.创建标识符修饰符("safestack"d);
        }
        case "SanitizeAddress"d: {
            return fc.创建标识符修饰符("sanitize_address"d);
        }
        case "SanitizeHWAddress"d: {
            return fc.创建标识符修饰符("sanitize_hwaddress"d);
        }
        case "SanitizeMemTag"d: {
            return fc.创建标识符修饰符("sanitize_memtag"d);
        }
        case "SanitizeMemory"d: {
            return fc.创建标识符修饰符("sanitize_memory"d);
        }
        case "SanitizeThread"d: {
            return fc.创建标识符修饰符("sanitize_thread"d);
        }
        case "ShadowCallStack"d: {
            return fc.创建标识符修饰符("shadowcallstack"d);
        }
        case "Speculatable"d: {
            return fc.创建标识符修饰符("speculatable"d);
        }
        case "SpeculativeLoadHardening"d: {
            return fc.创建标识符修饰符("speculative_load_hardening"d);
        }
        case "StackProtect"d: {
            return fc.创建标识符修饰符("ssp"d);
        }
        case "StackProtectReq"d: {
            return fc.创建标识符修饰符("sspreq"d);
        }
        case "StackProtectStrong"d: {
            return fc.创建标识符修饰符("sspstrong"d);
        }
        case "StrictFP"d: {
            return fc.创建标识符修饰符("strictfp"d);
        }
        case "SwiftAsync"d: {
            return fc.创建标识符修饰符("swiftasync"d);
        }
        case "SwiftError"d: {
            return fc.创建标识符修饰符("swifterror"d);
        }
        case "SwiftSelf"d: {
            return fc.创建标识符修饰符("swiftself"d);
        }
        case "UWTable"d: {
            return fc.创建标识符修饰符("uwtable"d);
        }
        case "WillReturn"d: {
            return fc.创建标识符修饰符("willreturn"d);
        }
        case "WriteOnly"d: {
            return fc.创建标识符修饰符("writeonly"d);
        }
        case "ZExt"d: {
            return fc.创建标识符修饰符("zeroext"d);
        }
        case "ByRef"d: {
            return fc.创建标识符修饰符("byref"d);
        }
        case "ByVal"d: {
            return fc.创建标识符修饰符("byval"d);
        }
        case "ElementType"d: {
            return fc.创建标识符修饰符("elementtype"d);
        }
        case "InAlloca"d: {
            return fc.创建标识符修饰符("inalloca"d);
        }
        case "Preallocated"d: {
            return fc.创建标识符修饰符("preallocated"d);
        }
        case "StructRet"d: {
            return fc.创建标识符修饰符("sret"d);
        }
        case "Alignment"d: {
            return fc.创建标识符修饰符("align_"d);
        }
        case "AllocSize"d: {
            return fc.创建标识符修饰符("allocsize"d);
        }
        case "Dereferenceable"d: {
            return fc.创建标识符修饰符("dereferenceable"d);
        }
        case "DereferenceableOrNull"d: {
            return fc.创建标识符修饰符("dereferenceable_or_null"d);
        }
        case "StackAlignment"d: {
            return fc.创建标识符修饰符("alignstack"d);
        }
        default: break;
    }
    // 最后一个
    return fc.创建标识符修饰符("vscale_range"d);
}
